package com.ithiema.reggie.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ithiema.reggie.common.GlobalConstant;
import com.ithiema.reggie.common.R;
import com.ithiema.reggie.entity.Category;
import com.ithiema.reggie.service.CategoryService;
import lombok.extern.java.Log;
import lombok.extern.slf4j.Slf4j;
import org.omg.PortableServer.THREAD_POLICY_ID;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.objenesis.instantiator.basic.DelegatingToExoticInstantiator;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

/**
 * 表示层  分类管理
 *
 * @author wangxiao
 * @since 2022/11/2 16:17
 */
@Slf4j
@RestController
@RequestMapping("/category")
public class CategoryController {
    @Autowired
    private CategoryService categoryService;
    /*
    新增分类
     */
    /*
    1.请求路径
    2.请求方式
    3.请求参数
    4.返回值
     */
    @PostMapping
    public R<String> save(@RequestBody Category categoryParam){
        log.info("前后端联通");
      log.info("category ==> {}", categoryParam.toString());
//      参数校验，分类名称
      boolean checkParam = this.checkParam(categoryParam);
    if (!checkParam){
        return R.error(GlobalConstant.FAILED);
    }
    boolean isFinished = this.categoryService.save(categoryParam);
    return isFinished ? R.success(GlobalConstant.SUCCESS):R.error(GlobalConstant.FAILED);
    }
/*
参数校验
 */
    private boolean checkParam(Category categoryParam) {
    if (StringUtils.isBlank(categoryParam.getName())){
        return Boolean.FALSE;
    }
    if (categoryParam.getSort() == null){
        return Boolean.FALSE;
    }
    if (categoryParam.getType() == null){
        return Boolean.FALSE;
    }
    return Boolean.TRUE;
    }
     /*
    分页查询
     */
    /*
    1.请求路径
    2.请求方式
    3.请求参数
    4.返回值
     */
    @GetMapping("/page")
    public R<Page<Category>> getPage(Integer page, Integer pageSize){
        log.info("前后端连接");
//        要有Page分页对象 ，在这个对象中 要赋值 当前页current,当前页要显示多少行Size
        Page<Category> queryPage = new Page<>();
//        当前页
        queryPage.setCurrent(page);
//        当前页显示多少行
        queryPage.setSize(pageSize);
//        排序从的条件
        LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();
//        根据sort字段做升序
//        升序 0 -> 10  降序 10 - > 0
        queryWrapper.orderByAsc(Category::getSort);
        Page<Category> result = this.categoryService.page(queryPage,queryWrapper);
//        会把查询后结果，保存到分页对象中
        return R.success(result);
    }
    /*
    根据id删除分类
     */
    @DeleteMapping
    public R<String> delete(Long id){
        log.info("删除分类，id为：{}",id);
        this.categoryService.deleteById(id);
        return R.success(GlobalConstant.SUCCESS);
    }
// 1. 请求路径
    // 2. 请求方式
    // 3. 请求参数
    // 4. 返回值
    /*
    修改分类
     */
    @PutMapping
    public R<String> update(@RequestBody Category categoryParam){
        log.info("前后端联通 ==> {}",categoryParam.toString());
//        参数校验
//        如果前端分类传入的名字是空则 发送操作失败
        if (StringUtils.isBlank(categoryParam.getName())){
            return R.error(GlobalConstant.FAILED);
        }

////      根据页面提交的名字查询数据库
//        LambdaQueryWrapper<Category> CategoryQueryWrapper = new LambdaQueryWrapper<>();
//        CategoryQueryWrapper.eq(Category::getName,categoryParam.getName());
////        getOne这个方法 从数据库只查取一个数据 有多个就会抛出异常，
//        Category category = categoryService.getOne(CategoryQueryWrapper);
////        如果没查到返回操作失败
//        if (category == null){
//            return R.error(GlobalConstant.FAILED);
//        }
////分类名字不养
//        if (category.getName().equals(categoryParam.getName())){
//            return R.error(GlobalConstant.FAILED);
//        }
//        走到这 说明正确可以修改
        this.categoryService.updateById(categoryParam);
        return R.success(GlobalConstant.SUCCESS);
    }
    /**
     * 查询分类列表
     *
     */
    @GetMapping("/list")
    public R<List<Category>> getCategoryList(Category categoryParam){
        log.info("前后端联通");
//                拼接查询条件
        LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();
//        这个type 有可能是不传递的   如果不为空  在拼接这个条件
        queryWrapper.eq(categoryParam.getType() != null,Category::getType,categoryParam.getType());
//        在这里使用链式编程的方式，来完成多个排序条件进行拼接，sort  升序，  修改时间  倒叙、
//        sql  升序 ASC sql  倒叙 DESC   sql写排序的方式 ORDER BY
//        SELECT * FROM CATEGORY WHERE (type = ?) ORDER BY sort ASC,update_time DESC
        queryWrapper.orderByAsc(Category::getSort).orderByDesc(Category::getUpdateTime);
//        查询分类
        List<Category> categoryList = this.categoryService.list(queryWrapper);
        return  R.success(categoryList);
    }
}
